package logica_de_negocio;

import java.util.HashSet;

import comun.Capitulo;
import comun.Serie;
import logica_de_datos.GestorBD;

public class gestorSerie {

	protected HashSet<Serie> listaSeries;
	final GestorBD objConversor = GestorBD.getInstance();

	public gestorSerie() {

		listaSeries = new HashSet<Serie>();
	}
	
	public void cargarDatos() throws ClassNotFoundException {// OK

		
			objConversor.connect();
			listaSeries = objConversor.listarSerie();
			objConversor.disconnect();
		
	}

	// TITULO>de la serie
	// NOMBRE__..> del serieitulo
	public void anadirS(Serie serie) throws excepAnadirDupli, ClassNotFoundException {// MIRAR
		cargarDatos();

		if (listaSeries.contains(serie)) {

			excepAnadirDupli dupli = new excepAnadirDupli();
			dupli.setDes("La serie con titulo " + serie.getTitulo()
					+ " ya esta en la base de datos");
			throw dupli;

		} else {
			
				objConversor.connect();
				objConversor.addSerie(serie);
				objConversor.disconnect();
			
		}
	}

	public boolean borrar(int id_s, ExcepDeleteOnCascade onCascade)
			throws FaltanDatosEnLaBaseDeDatos, ExcepDeleteOnCascade, ClassNotFoundException {// OK

		boolean rea = false;

			if (isId(id_s)) {// SI ESTA GUARDADO LO INTENTAMOS BORRAR

				gestorCapitulo gc = new gestorCapitulo();
				boolean permitido = onCascade.isAceptado();

				if (permitido == false) {
					if (gc.isId_s(id_s)) {
						throw onCascade;
					} else {
						permitido = true;
					}
				}

				if (permitido) {

					gestorCapituloVistaNoSi gcvns = new gestorCapituloVistaNoSi();
					gestorValoracionCapitulo gvc = new gestorValoracionCapitulo();
					GestorSigueSerie gss = new GestorSigueSerie();

					HashSet<Capitulo> lc = gc.getCapitulosId_s(id_s);
					boolean bool = false;
					if (lc.isEmpty()) {
						bool = true;
					}
					boolean relCVNS = bool;
					boolean relVC = bool;
					boolean bCap = bool;
					boolean relSigSe = false;
					boolean bSer = false;
					for (Capitulo c : lc) {
						if (gcvns.isId_c(c.getId_s())) {
							relCVNS = gcvns
									.deleteAllCapituloVistaNoSiFromId_C(c
											.getId_s());
						} else {
							relCVNS = true;
						}

						if (gvc.isId_c(c.getId_s())) {
							relVC = gvc.deleteAllValoracionCapituloFromId_C(c
									.getId_s());
						} else {
							relVC = true;
						}

						bCap = gc.borrarfin(c.getId_s());

					}
					if (gss.isId_s(id_s)) {
						relSigSe = gss.deleteAllSigueSerieFromId_s(id_s);
					} else {
						relSigSe = true;
					}
					bSer = borrarfin(id_s);
					if (bCap == true) {
						if (relVC == true) {
							if (relCVNS == true) {
								if (relSigSe) {
									if (bSer) {
										rea = true;
									}
								}
							}
						}
					}
				}
			} else {
				FaltanDatosEnLaBaseDeDatos f = new FaltanDatosEnLaBaseDeDatos();
				f.setFalta("No existe una serie con el id-" + id_s);
				throw f;
			}
			return rea;
		
	}

	private boolean borrarfin(int  id_s) throws ClassNotFoundException {
		boolean dev = false;
		
			objConversor.connect();
			objConversor.deleteSerie(id_s);// SOLO USA EL ID DEL OBJETO
			dev = true;
			objConversor.disconnect();
		
		return dev;
	}

	public Serie getSerie(int id) throws FaltanDatosEnLaBaseDeDatos, ClassNotFoundException {// OK
		cargarDatos();
		Serie dev = null;
		try {
			objConversor.connect();
			for (Serie c : listaSeries) {
				if (c.getId_s() == id) {
					dev = c;
				}
			}
			objConversor.disconnect();
		} catch (ClassNotFoundException e) {
		}
		// PARA NO DEVOLVER OBJETOS NULOS
		if (dev == null) {
			FaltanDatosEnLaBaseDeDatos f = new FaltanDatosEnLaBaseDeDatos();
			f.setFalta("No existe una serie en la base de datos con el id-"
					+ id);
			throw f;
		}
		return dev;
	}

	public Serie getSerie(String titulo) throws FaltanDatosEnLaBaseDeDatos, ClassNotFoundException {
		cargarDatos();
		Serie dev = null;
		try {
			objConversor.connect();
			for (Serie s : listaSeries) {
				if (s.getTitulo().equals(titulo)) {
					dev = s;
				}
			}
			objConversor.disconnect();
		} catch (ClassNotFoundException e) {
		}
		// PARA NO DEVOLVER OBJETOS NULOS
		if (dev == null) {
			FaltanDatosEnLaBaseDeDatos f = new FaltanDatosEnLaBaseDeDatos();
			f.setFalta("No existe una serie en la base de datos con el titulo-"
					+ titulo);
			throw f;
		}
		return dev;
	}

	public String[][] getTitulo() throws ClassNotFoundException {
		/**
		 * En la primera columna almacenamos en id de la serie "int" En la
		 * segunda almacenamos el titulo de la serie "String"
		 */
		cargarDatos();
		String[][] titulos = new String[listaSeries.size()][2];
		try {
			objConversor.connect();
			int i = 0;
			for (Serie serie : listaSeries) {
				Integer id = (Integer) serie.getId_s();
				titulos[i][0] = id.toString();
				titulos[i][1] = serie.getTitulo();
				i++;
			}
			objConversor.disconnect();
		} catch (ClassNotFoundException e) {
		}
		return titulos;
	}

	public boolean estaVacia() throws ClassNotFoundException {// OK
		cargarDatos();
		return listaSeries.isEmpty();
	}

	public boolean modifySerie(Serie obj) throws FaltanDatosEnLaBaseDeDatos,
			ExcepDatosNoAdmitidos, ClassNotFoundException {// OK

		cargarDatos();
		boolean dev = false;

		if (isId(obj.getId_s())) {
			// DEBE MANTENERSE QUE EL TITULO SEA UNICO
			if (regla(obj)) {
				
					objConversor.connect();
					objConversor.modifySerie(obj);
					dev = true;
					objConversor.disconnect();
				
			} else {
				throw new ExcepDatosNoAdmitidos();
			}
		} else {
			FaltanDatosEnLaBaseDeDatos f = new FaltanDatosEnLaBaseDeDatos();
			f.setFalta("No existe una serie con el id-" + obj.getId_s());
			throw f;
		}
		return dev;
	}

	private boolean regla(Serie obj) throws FaltanDatosEnLaBaseDeDatos, ClassNotFoundException {// OK
		boolean dev = true;
		Serie ser = getSerie(obj.getId_s());
		if (obj.equals(ser)) {// UNICAMENTE SE MODIFICAN ASPECTOS NO IMPORTANTES
			dev = true;
		} else {
			for (Serie s : listaSeries) {
				if (s.getTitulo().equals(obj.getTitulo())) {
					if (s.getId_s() != obj.getId_s()) {
						dev = false;// SI SOLO CUMPLE QUE EL TITULO ES IGUAL
					}
				}
			}
		}
		return dev;
	}

	public boolean reset() throws ClassNotFoundException {// OK
		cargarDatos();
		if (estaVacia()) {

		} else {
			listaSeries.clear();

			objConversor.connect();
			objConversor.resetSerie();
			objConversor.disconnect();

		}
		cargarDatos();
		if (estaVacia()) {
			return true;
		} else {
			return false;
		}
	}

	public HashSet<Serie> getSeries() throws ClassNotFoundException {// OK
		cargarDatos();
		return listaSeries;
	}

	public boolean isId(int id_s) throws ClassNotFoundException { // OK
		boolean esta = false;
		HashSet<Integer> ids;
		
			objConversor.connect();
			ids = objConversor.listarSerieSoloId();
			objConversor.disconnect();
		
		for (Integer inte : ids) {
			if (inte.intValue() == id_s) {
				esta = true;
			}
		}
		return esta;
	}

	public boolean anadido(Serie ser) throws ClassNotFoundException {

		cargarDatos();
		boolean con = false;
		for (Serie s : listaSeries) {
			if (s.getTitulo().equals(ser.getTitulo())) {
				if (s.getDirector().equals(ser.getDirector())) {
					con = true;
				}
			}
		}
		return con;
	}
}